// 兵
function soldiers(piece, empty) {
  // 判断 阵营
  if (piece.imgName.indexOf("red") > -1) {
    // 判断是否 过河
    if (piece.x >= 510) {
      // 判断是否 直线且只走一格
      if (
        (empty.y == piece.y && empty.x == piece.x + 100) ||
        (empty.x == piece.x &&
          (empty.y == piece.y + 100 || empty.y == piece.y - 100))
      ) {
        return true;
      } else {
        return false;
      }
    } else {
      if (empty.y == piece.y && empty.x == piece.x + 100) {
        return true;
      } else {
        return false;
      }
    }
  } else {
    if (piece.x <= 410) {
      if (
        (empty.y == piece.y && empty.x == piece.x - 100) ||
        (empty.x == piece.x &&
          (empty.y == piece.y - 100 || empty.y == piece.y + 100))
      ) {
        return true;
      } else {
        return false;
      }
    } else {
      if (empty.y == piece.y && empty.x == piece.x - 100) {
        return true;
      } else {
        return false;
      }
    }
  }
}

// 车
function car(piece, empty, pieces) {
  // 判断 是否是 直线
  if (empty.x != piece.x && empty.y != piece.y) {
    return false;
    // 判断 方向 竖/横
  } else if (empty.x != piece.x) {
    // 判断 最大值与最小值
    if (empty.x > piece.x) {
      // 判断 最值中间是否有棋子
      if (
        pieces.some((v) => v.y == empty.y && v.x < empty.x && v.x > piece.x)
      ) {
        return false;
      } else {
        return true;
      }
    } else {
      if (
        pieces.some((v) => v.y == empty.y && v.x > empty.x && v.x < piece.x)
      ) {
        return false;
      } else {
        return true;
      }
    }
    // 判断 方向 竖/横
  } else if (empty.y != piece.y) {
    // 判断 最大值与最小值
    if (empty.y > piece.y) {
      // 判断 最值中间是否有棋子
      if (
        pieces.some((v) => v.x == empty.x && v.y < empty.y && v.y > piece.y)
      ) {
        return false;
      } else {
        return true;
      }
    } else {
      if (
        pieces.some((v) => v.x == empty.x && v.y > empty.y && v.y < piece.y)
      ) {
        return false;
      } else {
        return true;
      }
    }
  }
}

// 炮
function cannon(piece, empty, pieces) {
  // 判断是否 直线
  if (empty.x != piece.x && empty.y != piece.y) {
    return false;
    // 判断 方向 竖/横
  } else if (empty.x != piece.x) {
    // 判断 最大和最小
    if (empty.x > piece.x) {
      let firstIndex = pieces.findIndex(
        (v) => v.y == empty.y && v.x < empty.x && v.x > piece.x
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.y == empty.y && v.x < empty.x && v.x > piece.x
      );
      // 判断 最值中间是否只有一个棋子
      if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    } else {
      let firstIndex = pieces.findIndex(
        (v) => v.y == empty.y && v.x > empty.x && v.x < piece.x
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.y == empty.y && v.x > empty.x && v.x < piece.x
      );
      if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    }
  } else if (empty.y != piece.y) {
    if (empty.y > piece.y) {
      let firstIndex = pieces.findIndex(
        (v) => v.x == empty.x && v.y < empty.y && v.y > piece.y
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.x == empty.x && v.y < empty.y && v.y > piece.y
      );
      if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    } else {
      let firstIndex = pieces.findIndex(
        (v) => v.x == empty.x && v.y > empty.y && v.y < piece.y
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.x == empty.x && v.y > empty.y && v.y < piece.y
      );
      if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    }
  } else {
    return false;
  }
}

//攻击炮
function attackCannon(piece, empty, pieces) {
  if (empty.x != piece.x && empty.y != piece.y) {
    return false;
  } else if (empty.x != piece.x) {
    if (empty.x > piece.x) {
      let firstIndex = pieces.findIndex(
        (v) => v.y == empty.y && v.x < empty.x && v.x > piece.x
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.y == empty.y && v.x < empty.x && v.x > piece.x
      );
      // 判断 最值中间 是否有棋子
      if (firstIndex == -1 && lastIndex == -1) {
        return false;
      } else if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    } else {
      let firstIndex = pieces.findIndex(
        (v) => v.y == empty.y && v.x > empty.x && v.x < piece.x
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.y == empty.y && v.x > empty.x && v.x < piece.x
      );
      if (firstIndex == -1 && lastIndex == -1) {
        return false;
      } else if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    }
  } else if (empty.y != piece.y) {
    if (empty.y > piece.y) {
      let firstIndex = pieces.findIndex(
        (v) => v.x == empty.x && v.y < empty.y && v.y > piece.y
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.x == empty.x && v.y < empty.y && v.y > piece.y
      );
      if (firstIndex == -1 && lastIndex == -1) {
        return false;
      } else if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    } else {
      let firstIndex = pieces.findIndex(
        (v) => v.x == empty.x && v.y > empty.y && v.y < piece.y
      );
      let lastIndex = pieces.findLastIndex(
        (v) => v.x == empty.x && v.y > empty.y && v.y < piece.y
      );
      if (firstIndex == -1 && lastIndex == -1) {
        return false;
      } else if (firstIndex != lastIndex && firstIndex > -1 && lastIndex > -1) {
        return false;
      } else {
        return true;
      }
    }
  } else {
    return false;
  }
}

// 将
function general(piece, empty) {
  // 判断 是否直线 且 只走一格
  if (
    (empty.y == piece.y &&
      (empty.x == piece.x + 100 || empty.x == piece.x - 100)) ||
    (empty.x == piece.x &&
      (empty.y == piece.y + 100 || empty.y == piece.y - 100))
  ) {
    // 判断阵营
    if (piece.imgName.indexOf("red") > -1) {
      // 判断是否在 九宫格内
      if (empty.y <= 510 && empty.y >= 310 && empty.x <= 210 && empty.x >= 10) {
        return true;
      } else {
        return false;
      }
    } else {
      if (
        empty.y <= 510 &&
        empty.y >= 310 &&
        empty.x <= 910 &&
        empty.x >= 710
      ) {
        return true;
      } else {
        return false;
      }
    }
  } else {
    return false;
  }
}

// 士
function soldier(piece, empty) {
  // 判断 是否 斜线 且 只走一格
  if (
    (empty.x == piece.x + 100 || empty.x == piece.x - 100) &&
    (empty.y == piece.y + 100 || empty.y == piece.y - 100)
  ) {
    // 判断阵营
    if (piece.imgName.indexOf("red") > -1) {
      // 判断 是否 在九宫格内
      if (empty.y <= 510 && empty.y >= 310 && empty.x <= 210 && empty.x >= 10) {
        return true;
      } else {
        return false;
      }
    } else {
      if (
        empty.y <= 510 &&
        empty.y >= 310 &&
        empty.x <= 910 &&
        empty.x >= 710
      ) {
        return true;
      } else {
        return false;
      }
    }
  } else {
    return false;
  }
}

// 相
function phase(piece, empty, pieces) {
  // 判断 是否直线
  if (empty.x != piece.x && empty.y != piece.y) {
    // 判断 是否 【田】字形
    if (
      (empty.x == piece.x + 200 || empty.x == piece.x - 200) &&
      (empty.y == piece.y + 200 || empty.y == piece.y - 200)
    ) {
      // 判断 方向 右前/左前/右后/左后
      if (empty.x > piece.x && empty.y < piece.y) {
        // 判断 中间是否 有棋子 绊脚
        if (!pieces.some((v) => v.x == piece.x + 100 && v.y == piece.y - 100)) {
          // 判断阵营
          if (piece.imgName.indexOf("red") > -1) {
            // 判断是否过河
            if (empty.x <= 410) {
              return true;
            } else {
              return false;
            }
          } else {
            if (empty.x >= 510) {
              return true;
            } else {
              return false;
            }
          }
        } else {
          return false;
        }
      } else if (empty.x > piece.x && empty.y > piece.y) {
        if (!pieces.some((v) => v.x == piece.x + 100 && v.y == piece.y + 100)) {
          if (piece.imgName.indexOf("red") > -1) {
            if (empty.x <= 410) {
              return true;
            } else {
              return false;
            }
          } else {
            if (empty.x >= 510) {
              return true;
            } else {
              return false;
            }
          }
        } else {
          return false;
        }
      } else if (empty.x < piece.x && empty.y < piece.y) {
        if (!pieces.some((v) => v.x == piece.x - 100 && v.y == piece.y - 100)) {
          if (piece.imgName.indexOf("red") > -1) {
            if (empty.x <= 410) {
              return true;
            } else {
              return false;
            }
          } else {
            if (empty.x >= 510) {
              return true;
            } else {
              return false;
            }
          }
        } else {
          return false;
        }
      } else if (empty.x < piece.x && empty.y > piece.y) {
        if (!pieces.some((v) => v.x == piece.x - 100 && v.y == piece.y + 100)) {
          if (piece.imgName.indexOf("red") > -1) {
            if (empty.x <= 410) {
              return true;
            } else {
              return false;
            }
          } else {
            if (empty.x >= 510) {
              return true;
            } else {
              return false;
            }
          }
        } else {
          return false;
        }
      }
    } else {
      return false;
    }
  } else {
    return false;
  }
}

// 马
function horse(piece, empty, pieces) {
  // 判断是否直线
  if (piece.x != empty.x && piece.y != empty.y) {
    // 判断 是否【日】字形
    if (
      ((empty.x == piece.x + 100 || empty.x == piece.x - 100) &&
        (empty.y == piece.y + 200 || empty.y == piece.y - 200)) ||
      ((empty.x == piece.x + 200 || empty.x == piece.x - 200) &&
        (empty.y == piece.y + 100 || empty.y == piece.y - 100))
    ) {
      // 判断 有无棋子绊脚  false(有)
      if (pieces.some((v) => v.x == piece.x + 100 && v.y == piece.y)) {
        if (
          empty.x == piece.x + 200 &&
          (empty.y == piece.y + 100 || empty.y == piece.y - 100)
        ) {
          return false;
        }
      }
      if (pieces.some((v) => v.x == piece.x - 100 && v.y == piece.y)) {
        if (
          empty.x == piece.x - 200 &&
          (empty.y == piece.y + 100 || empty.y == piece.y - 100)
        ) {
          return false;
        }
      }
      if (pieces.some((v) => v.y == piece.y + 100 && v.x == piece.x)) {
        if (
          empty.y == piece.y + 200 &&
          (empty.x == piece.x + 100 || empty.x == piece.x - 100)
        ) {
          return false;
        }
      }
      if (pieces.some((v) => v.y == piece.y - 100 && v.x == piece.x)) {
        if (
          empty.y == piece.y - 200 &&
          (empty.x == piece.x + 100 || empty.x == piece.x - 100)
        ) {
          return false;
        }
      }
      return true;
    } else {
      return false;
    }
  } else {
    return false;
  }
}

// 判断点击的棋子是什么类型
function estimatePiece(piece, empty, pieces) {
  const { imgName } = piece;
  switch (imgName) {
    case "red_soldiers": // 兵
      return soldiers(piece, empty);
    case "black_soldiers":
      return soldiers(piece, empty);
    case "red_gun": // 炮
      return cannon(piece, empty, pieces);
    case "black_gun":
      return cannon(piece, empty, pieces);
    case "red_car": // 车
      return car(piece, empty, pieces);
    case "black_car":
      return car(piece, empty, pieces);
    case "black_general": // 将
      return general(piece, empty);
    case "red_general":
      return general(piece, empty);
    case "black_horse": // 马
      return horse(piece, empty, pieces);
    case "red_horse":
      return horse(piece, empty, pieces);
    case "black_phase": // 相
      return phase(piece, empty, pieces);
    case "red_phase":
      return phase(piece, empty, pieces);
    case "black_soldier": // 士
      return soldier(piece, empty);
    case "red_soldier":
      return soldier(piece, empty);
  }
}

// 判断点击的棋子是什么类型 -- 攻击时 (炮特殊)
function estimatePlayPiece(piece, empty, pieces) {
  const { imgName } = piece;
  switch (imgName) {
    case "red_soldiers": // 兵
      return soldiers(piece, empty);
    case "black_soldiers":
      return soldiers(piece, empty);
    case "red_gun": // 攻击炮
      return attackCannon(piece, empty, pieces);
    case "black_gun":
      return attackCannon(piece, empty, pieces);
    case "red_car": // 车
      return car(piece, empty, pieces);
    case "black_car":
      return car(piece, empty, pieces);
    case "black_general": // 将
      return general(piece, empty);
    case "red_general":
      return general(piece, empty);
    case "black_horse": // 马
      return horse(piece, empty, pieces);
    case "red_horse":
      return horse(piece, empty, pieces);
    case "black_phase": // 相
      return phase(piece, empty, pieces);
    case "red_phase":
      return phase(piece, empty, pieces);
    case "black_soldier": // 士
      return soldier(piece, empty);
    case "red_soldier":
      return soldier(piece, empty);
  }
}

// 判断吃子时棋子是否满足规则
function playChess(executePiece, targetPiece, pieces, index) {
  if (executePiece) {
    // 判断 棋子 是否满足 攻击规则(走法规则) 炮特殊
    if (estimatePlayPiece(executePiece, targetPiece, pieces)) {
      // 判断 攻击棋子 与 目标棋子 是否是 不同阵营
      if (
        (executePiece.imgName.indexOf("red") > -1 &&
          targetPiece.imgName.indexOf("black") > -1) ||
        (executePiece.imgName.indexOf("black") > -1 &&
          targetPiece.imgName.indexOf("red") > -1)
      ) {
        return true;
      } else {
        return false;
      }
    }
  } else {
    return false;
  }
}
